home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / raytrace / radiance / simplerd.lha / simplerad / FinalFTP / WalkT / auto.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-20  |  16.0 KB  |  526 lines
  1. /**********************************************************************/
  2. /*                                                                    */
  3. /* auto.c : Routines to handle automatic movement throught a scene    */
  4. /*                                                                    */
  5. /* Copyright (C) 1992, Bernard Kwok                                   */
  6. /* All rights reserved.                                               */
  7. /* Revision 1.0                                                       */
  8. /* May, 1992                                                          *
  9. /**********************************************************************/
  10. #include <stdio.h>
  11. #include <gl/gl.h>
  12. #include <fmclient.h>
  13. #include <gl/device.h>
  14. #define IRIS4D 1
  15. #include "geo.h"
  16. #include "walk.h"
  17. #include "auto.h"
  18.  
  19. /**********************************************************************/
  20. /* Create a relative move structure                                   */
  21. /**********************************************************************/
  22. AbsMovement *CreateAbsMove(camera)
  23.      AbsMovement camera;
  24. {
  25.   AbsMovement *amptr;
  26.  
  27.   if ((amptr = (AbsMovement *) malloc(sizeof(AbsMovement))) == 0) 
  28.     fprintf(stderr,"walk: Insufficient memory to store movement. Sorry.\n");
  29.   amptr->lookFrom = camera.lookFrom;
  30.   amptr->lookAt = camera.lookAt;
  31.   amptr->lookUp = camera.lookUp;
  32.   amptr->fovx = camera.fovx;  amptr->fovy = camera.fovy;
  33.   amptr->near = camera.near;  amptr->far = camera.far;
  34.   amptr->xRes = camera.xRes;  amptr->yRes = camera.yRes; 
  35.   amptr->bank = camera.bank;
  36.   amptr->buffer = (unsigned long *)0;
  37.   /* malloc(camera.xRes*camera.yRes * sizeof(unsigned long)); */
  38.   
  39.   return amptr;
  40. }
  41.  
  42. /**********************************************************************/
  43. /* Create a relative move structure                                   */
  44. /**********************************************************************/
  45. RelMovement *CreateRelMove(rot, transl)
  46.      double rot[3];
  47.      double transl[3];
  48. {
  49.   RelMovement *rmptr;
  50.  
  51.   if ((rmptr = (RelMovement *) malloc(sizeof(RelMovement))) == 0) 
  52.     fprintf(stderr,"walk: Insufficient memory to store movement. Sorry.\n");
  53.   rmptr->rot[0] = rot[0];
  54.   rmptr->rot[1] = rot[1];
  55.   rmptr->rot[2] = rot[2];
  56.   rmptr->transl[0] = transl[0];
  57.   rmptr->transl[1] = transl[1];
  58.   rmptr->transl[2] = transl[2];
  59.  
  60.   return rmptr;
  61. }
  62.   
  63. /**********************************************************************/
  64. /* Output contents of an absolute move to screen */
  65. /**********************************************************************/
  66. void PrintAbsMove(amove)
  67.      AbsMovement *amove;
  68. {
  69.   printf("Move A {\n");
  70.  
  71.   printf("  lookFrom %g %g %g\n", amove->lookFrom.x, 
  72.      amove->lookFrom.y, amove->lookFrom.z);
  73.   printf("  lookAt %g %g %g\n", amove->lookAt.x,
  74.      amove->lookAt.y, amove->lookAt.z);
  75.   printf("  lookUp %g %g %g\n", amove->lookUp.x, 
  76.      amove->lookUp.y, amove->lookUp.z);
  77.   printf("  fovx %d fovy %d near %g far %g\n",
  78.      amove->fovx, amove->fovy, amove->near, amove->far);
  79.   printf("  xRes %d yRes %d\n", amove->xRes, amove->yRes);
  80.   printf("  bank %g\n", amove->bank);
  81.  
  82.   printf("}\n");
  83. }
  84.  
  85. /**********************************************************************/
  86. /* Output contents of a relative move to screen */
  87. /**********************************************************************/
  88. void PrintRelMove(rmove, mtype)
  89.      RelMovement *rmove;
  90.      int mtype;
  91. {
  92.   switch(mtype) {
  93.  
  94.   case MOVEREL_ROT: 
  95.     printf("Move R {\n");
  96.     printf("%g %g %g\n", rmove->rot[0],
  97.        rmove->rot[1], rmove->rot[2]);
  98.     break;
  99.  
  100.   case MOVEREL_SPIN: 
  101.     printf("Move P {\n");
  102.     printf("%g %g %g\n", rmove->rot[0],
  103.        rmove->rot[1], rmove->rot[2]);
  104.     break;
  105.  
  106.   case MOVEREL_TRANSL: 
  107.     printf("Move T {\n");
  108.     printf("%g %g %g\n", rmove->transl[0],
  109.        rmove->transl[1], rmove->transl[2]);
  110.     break;
  111.  
  112.   case MOVEREL_SCALE: 
  113.     printf("Move S {\n");
  114.     printf("%g %g %g\n", rmove->transl[0],
  115.        rmove->transl[1], rmove->transl[2]);
  116.     break;
  117.  
  118.   case MOVEREL_ZOOM: 
  119.     printf("Move Z {\n");
  120.     printf("%g %g %g\n", rmove->transl[0],
  121.        rmove->transl[1], rmove->transl[2]);
  122.     break;
  123.  
  124.   default: 
  125.     fprintf(stderr,"%s: Invalid movement to print: %d\n", ProgName, mtype);
  126.     exit(-1); /* DoExit(-1); */
  127.   }
  128.   printf("}\n");
  129. }
  130.  
  131. /**********************************************************************/
  132. /* Clear any stored orientations                                      */
  133. /**********************************************************************/
  134. void ClearOrientLog()
  135. {
  136.   if (Option.debug) printf("Clearing log\n");
  137.   if (Autoview) free(Autoview); 
  138.   /* if (Mtail) free(Mtail); */
  139.   moves_logged = 0;
  140.   Option.log = NOLOG;
  141. }
  142.  
  143. /**********************************************************************/
  144. /* Open movement file                                                 */
  145. /**********************************************************************/
  146. int OpenMoveFile(filename,mode)
  147.      char *filename, *mode;
  148. {
  149.   if (!(movefile = fopen(filename,mode))) {
  150.     fprintf(stderr,"%s: cannot open file %s\n", ProgName, filename);
  151.     return 0;
  152.   }
  153.   return 1;
  154. }
  155.  
  156. /**********************************************************************/
  157. /* Read movements from file                                           */
  158. /**********************************************************************/
  159. int ReadMoves(filename, moves)
  160.      char *filename;
  161.      Movement **moves;
  162. {
  163.   int num_relmoves = 0;
  164.   int num_absmoves = 0;
  165.   int num_moves = 0;
  166.   int moves_read = 0;
  167.   Movement *mptr, *nmptr;
  168.   int t1,t2;
  169.   float t[4];
  170.  
  171.   if (!OpenMoveFile(filename,READF)) {
  172.     exit(-1); /* DoExit(-1); */
  173.   } else if (Option.debug) {
  174.     printf("Reading moves from %s\n", filename);
  175.   }
  176.  
  177.   /* Allocate space for moves */
  178.   fscanf(movefile,"nmoves %d\n", &num_moves);
  179.   if ((mptr = *moves = (Movement *) malloc(num_moves * sizeof(Movement)))
  180.       == 0) {
  181.     fprintf(stderr,"walk: Insufficient memory to load movements. Sorry.\n");
  182.     exit(1);
  183.   }
  184.  
  185.   /* Read in absolute or relative camera movements */
  186.   while (moves_read < num_moves) {
  187.     fscanf(movefile, "Move %c {\n", &Movetype);
  188.     if (Option.debug) printf("Movetype: %c\n", Movetype);
  189.  
  190.     mptr->mtype = Movetype;
  191.     switch (Movetype) {
  192.  
  193.     case MOVEABS: {
  194.       if ((mptr->amove = (AbsMovement *) malloc(sizeof(AbsMovement))) == 0) {
  195.     fprintf(stderr,
  196.         "walk: Insufficient memory to load movement. Sorry.\n");
  197.       exit(1);
  198.       }
  199.  
  200.       fscanf(movefile, "lookFrom %g %g %g\n", &t[0], &t[1], &t[2]);
  201.       if (Option.debug) printf("\tlookFrom %g %g %g\n", t[0], t[1], t[2]);
  202.       mptr->amove->lookFrom.x = t[0];
  203.       mptr->amove->lookFrom.y = t[1];
  204.       mptr->amove->lookFrom.z = t[2];
  205.  
  206.       fscanf(movefile, "lookAt %g %g %g\n", &t[0], &t[1], &t[2]);
  207.       if (Option.debug) printf("\tlookAt %g %g %g\n", t[0], t[1], t[2]);
  208.       mptr->amove->lookAt.x = t[0];
  209.       mptr->amove->lookAt.y = t[1];
  210.       mptr->amove->lookAt.z = t[2];
  211.  
  212.       fscanf(movefile, "lookUp %g %g %g\n", &t[0], &t[1], &t[2]);
  213.       if (Option.debug) printf("\tlookup %g %g %g\n", t[0], t[1], t[2]);
  214.       mptr->amove->lookUp.x = t[0];
  215.       mptr->amove->lookUp.y = t[1];
  216.       mptr->amove->lookUp.z = t[2];
  217.  
  218.       fscanf(movefile, "fovx %d fovy %d near %g far %g\n",&t1,&t2,&t[0],&t[1]);
  219.       mptr->amove->fovx = t1; mptr->amove->fovy = t2;
  220.       mptr->amove->near = t[0]; mptr->amove->far = t[1];
  221.       if (Option.debug) 
  222.     printf("\tfovx %d fovy %d near %g far %g\n", t1, t2, t[0], t[1]);
  223.       
  224.       fscanf(movefile,"xRes %d yRes %d\n", &t1, &t2);
  225.       mptr->amove->xRes = t1; mptr->amove->yRes = t2;
  226.       if (Option.debug) printf("\txRes %d yRes %d\n", t1, t2);
  227.  
  228.       fscanf(movefile, "bank %g\n", &t[0]);
  229.       mptr->amove->bank = t[0];
  230.       if (Option.debug) printf("\tbank %g\n", t[0]);
  231.  
  232.       fscanf(movefile, "}\n");
  233.  
  234.       /* Allocate buffer for image storage purposes */
  235.       mptr->amove->buffer = (unsigned  long *)0;
  236.       /* malloc(mptr->amove->xRes * mptr->amove->yRes * 
  237.      sizeof(unsigned long)); */
  238.  
  239.       num_absmoves++;
  240.       break;
  241.     }
  242.  
  243.     case MOVEREL_ROT: {
  244.       if ((mptr->rmove = (RelMovement *) malloc(sizeof(RelMovement))) == 0) {
  245.     fprintf(stderr,
  246.         "walk: Insufficient memory to load movement. Sorry.\n");
  247.     exit(1);
  248.       }
  249.       fscanf(movefile,"%g %g %g\n", &t[0], &t[1], &t[2]);
  250.       if (Option.debug) printf("\t%g, %g, %g\n", t[0], t[1], t[2]);
  251.       mptr->rmove->rot[0] = t[0];
  252.       mptr->rmove->rot[1] = t[1];
  253.       mptr->rmove->rot[2] = t[2];
  254.       fscanf(movefile,"}\n");
  255.       num_relmoves++;
  256.       break;
  257.     }
  258.  
  259.     case MOVEREL_SPIN: {
  260.       if ((mptr->rmove = (RelMovement *) malloc(sizeof(RelMovement))) == 0) {
  261.     fprintf(stderr,
  262.         "walk: Insufficient memory to load movement. Sorry.\n");
  263.     exit(1);
  264.       }
  265.       fscanf(movefile,"%g %g %g\n", &t[0], &t[1], &t[2]);
  266.       if (Option.debug) printf("\t%g, %g, %g\n", t[0], t[1], t[2]);
  267.       mptr->rmove->rot[0] = t[0];
  268.       mptr->rmove->rot[1] = t[1];
  269.       mptr->rmove->rot[2] = t[2];
  270.       fscanf(movefile,"}\n");
  271.       num_relmoves++;
  272.       break;
  273.     }
  274.  
  275.     case MOVEREL_TRANSL: {
  276.       if ((mptr->rmove = (RelMovement *) malloc(sizeof(RelMovement))) == 0) {
  277.     fprintf(stderr,
  278.         "walk: Insufficient memory to load movement. Sorry.\n");
  279.     exit(1);
  280.       }
  281.       fscanf(movefile,"%g %g %g\n", &t[0], &t[1], &t[2]);
  282.       if (Option.debug) printf("\t%g, %g, %g\n", t[0], t[1], t[2]);
  283.       mptr->rmove->transl[0] = t[0];
  284.       mptr->rmove->transl[1] = t[1];
  285.       mptr->rmove->transl[2] = t[2];
  286.       
  287.       fscanf(movefile,"}\n");
  288.       num_relmoves++;
  289.       break;
  290.     }
  291.  
  292.     case MOVEREL_SCALE: {
  293.       if ((mptr->rmove = (RelMovement *) malloc(sizeof(RelMovement))) == 0) {
  294.     fprintf(stderr,
  295.         "walk: Insufficient memory to load movement. Sorry.\n");
  296.     exit(1);
  297.       }
  298.       fscanf(movefile,"%g %g %g\n", &t[0], &t[1], &t[2]);
  299.       if (Option.debug) printf("\t%g, %g, %g\n", t[0], t[1], t[2]);
  300.       mptr->rmove->transl[0] = t[0];
  301.       mptr->rmove->transl[1] = t[1];
  302.       mptr->rmove->transl[2] = t[2];
  303.  
  304.       fscanf(movefile,"}\n");
  305.       num_relmoves++;
  306.       break;
  307.     }
  308.  
  309.     case MOVEREL_ZOOM: {
  310.       if ((mptr->rmove = (RelMovement *) malloc(sizeof(RelMovement))) == 0) {
  311.     fprintf(stderr,
  312.         "walk: Insufficient memory to load movement. Sorry.\n");
  313.     exit(1);
  314.       }
  315.       fscanf(movefile,"%g %g %g\n", &t[0], &t[1], &t[2]);
  316.       if (Option.debug) printf("\t%g, %g, %g\n", t[0], t[1], t[2]);
  317.       mptr->rmove->transl[0] = t[0];
  318.       mptr->rmove->transl[1] = t[1];
  319.       mptr->rmove->transl[2] = t[2];
  320.  
  321.       fscanf(movefile,"}\n");
  322.       num_relmoves++;
  323.       break;
  324.     }
  325.       
  326.     default: {
  327.       fprintf(stderr,"%s: Invalid movement read from %s\n", ProgName,
  328.           filename);
  329.       exit(-1); /* DoExit(-1); */
  330.       break;
  331.     }
  332.     }
  333.     nmptr = (mptr+1);
  334.     mptr->next = nmptr;
  335.     mptr++;
  336.     moves_read++;
  337.   }
  338.   fclose(movefile);
  339.   if (Option.debug) {
  340.     printf("\n\tNumber of absolute moves   = %d\n", num_absmoves);
  341.     printf("\tNumber of relative moves   = %d\n", num_relmoves);
  342.     printf("\tTotal moves read from file = %d\n\n", num_moves);
  343.   }
  344.   return (num_moves);
  345. }
  346.  
  347. /**********************************************************************/
  348. /* Log a relative move */
  349. /**********************************************************************/
  350. void LogRelMove(rmove, moves, mtype)
  351.      RelMovement *rmove;
  352.      Movement **moves;
  353.      char mtype;
  354. {
  355.   Movement *nmptr;
  356.  
  357.   if (moves_logged == 0) {
  358.     if ((Mtail = *moves = nmptr = (Movement *) malloc(sizeof(Movement)))== 0) {
  359.       fprintf(stderr, "walk: Insufficient memory to log movement. Sorry.\n");
  360.       exit(1);
  361.     }
  362.     nmptr->mtype = mtype;
  363.     nmptr->rmove = rmove;
  364.   } else {
  365.     if ((Mtail->next = nmptr = (Movement *) malloc(sizeof(Movement))) == 0) {
  366.       fprintf(stderr, "walk: Insufficient memory to log movement. Sorry.\n");
  367.       exit(1);
  368.     }
  369.     nmptr->mtype = mtype;
  370.     /* printf("mtype = %c\n", mtype); */
  371.     nmptr->rmove = rmove;
  372.     Mtail = nmptr;
  373.   }
  374.   moves_logged++;
  375. }
  376.   
  377. /**********************************************************************/
  378. /* Log an absolute move */
  379. /**********************************************************************/
  380. void LogAbsMove(amove, moves, mtype)
  381.      AbsMovement *amove;
  382.      Movement **moves;
  383.      char mtype;
  384. {
  385.   Movement *nmptr;
  386.  
  387.   if (moves_logged == 0) {
  388.     if ((Mtail = *moves = nmptr = (Movement *) malloc(sizeof(Movement)))== 0) {
  389.       fprintf(stderr, "walk: Insufficient memory to log movement. Sorry.\n");
  390.       exit(1);
  391.     }
  392.     nmptr->mtype = mtype;
  393.     nmptr->amove = amove;
  394.   } else {
  395.     if ((Mtail->next = nmptr = (Movement *) malloc(sizeof(Movement))) == 0) {
  396.       fprintf(stderr, "walk: Insufficient memory to log movement. Sorry.\n");
  397.       exit(1);
  398.     }
  399.     nmptr->mtype = mtype;
  400.     nmptr->amove = amove;
  401.     Mtail = nmptr;
  402.   }
  403.   moves_logged++;
  404. }
  405.  
  406. /**********************************************************************/
  407. /* Open logging file for output */
  408. /**********************************************************************/
  409. void InitMoveLog(filename,mode,nmoves)
  410.      char *filename, *mode;
  411.      int nmoves;
  412. {
  413.   if (!OpenMoveFile(filename,mode)) {
  414.     exit(-1); 
  415.   } else if (Option.debug) {
  416.     printf("\nWriting moves to %s\n", filename);
  417.   }
  418.   fprintf(movefile,"%s %d\n", HEAD_NMOVES, nmoves);
  419. }
  420.  
  421. /**********************************************************************/
  422. /* Write an relative move to file */
  423. /**********************************************************************/
  424. void WriteRelMove(rmove, mtype)
  425.      RelMovement *rmove;
  426.      int mtype;
  427. {
  428.   switch(mtype) {
  429.   case MOVEREL_ROT: 
  430.     fprintf(movefile,"Move R {\n");
  431.     fprintf(movefile,"%g %g %g\n", rmove->rot[0],
  432.         rmove->rot[1], rmove->rot[2]);
  433.     break;
  434.  
  435.   case MOVEREL_SPIN: 
  436.     fprintf(movefile,"Move P {\n");
  437.     fprintf(movefile,"%g %g %g\n", rmove->rot[0],
  438.         rmove->rot[1], rmove->rot[2]);
  439.     break;
  440.  
  441.   case MOVEREL_TRANSL: 
  442.     fprintf(movefile,"Move T {\n");
  443.     fprintf(movefile,"%g %g %g\n", rmove->transl[0],
  444.         rmove->transl[1], rmove->transl[2]);
  445.     break;
  446.  
  447.   case MOVEREL_SCALE: 
  448.     fprintf(movefile,"Move S {\n");
  449.     fprintf(movefile,"%g %g %g\n", rmove->transl[0],
  450.         rmove->transl[1], rmove->transl[2]);
  451.     break;
  452.     
  453.   case MOVEREL_ZOOM: 
  454.     fprintf(movefile,"Move Z {\n");
  455.     fprintf(movefile,"%g %g %g\n", rmove->transl[0],
  456.         rmove->transl[1], rmove->transl[2]);
  457.     break;
  458.  
  459.   default: 
  460.     fprintf(stderr,"%s: Invalid movement to write: %c\n", ProgName, mtype);
  461.     exit(-1); /* DoExit(-1); */
  462.   }
  463.   fprintf(movefile,"}\n");
  464. }
  465.  
  466. /**********************************************************************/
  467. /* Write an absolute move to file */
  468. /**********************************************************************/
  469. void WriteAbsMove(amove)
  470.      AbsMovement *amove;
  471. {
  472.   fprintf(movefile,"Move A {\n");
  473.  
  474.   fprintf(movefile, "  lookFrom %g %g %g\n", (amove->lookFrom.x),
  475.       (amove->lookFrom.y), (amove->lookFrom.z));
  476.   fprintf(movefile, "  lookAt %g %g %g\n", (amove->lookAt.x),
  477.       (amove->lookAt.y), (amove->lookAt.z));
  478.   fprintf(movefile, "  lookUp %g %g %g\n", (amove->lookUp.x),
  479.       (amove->lookUp.y), (amove->lookUp.z));
  480.   fprintf(movefile, "  fovx %d fovy %d near %g far %g\n",
  481.       amove->fovx, amove->fovy, amove->near, amove->far);
  482.   fprintf(movefile, "  xRes %d yRes %d\n", amove->xRes, amove->yRes);
  483.   fprintf(movefile, "  bank %g\n", (amove->bank));
  484.  
  485.   fprintf(movefile,"}\n");
  486. }
  487.  
  488. /**********************************************************************/
  489. /* Write movements to file */
  490. /**********************************************************************/
  491. int WriteMoves(filename, moves, nmoves)
  492.      char *filename;
  493.      Movement *moves;
  494.      int nmoves;
  495. {
  496.   int i;
  497.  
  498.   InitMoveLog(filename,WRITEF,nmoves);
  499.   for(i=0;i<nmoves;i++) {
  500.     if (moves->mtype == MOVEREL_ROT) 
  501.       WriteRelMove(moves->rmove, MOVEREL_ROT);
  502.     else if (moves->mtype == MOVEREL_SPIN) 
  503.       WriteRelMove(moves->rmove, MOVEREL_SPIN);
  504.     else if (moves->mtype == MOVEREL_TRANSL) 
  505.       WriteRelMove(moves->rmove, MOVEREL_TRANSL);
  506.     else if (moves->mtype == MOVEREL_SCALE) 
  507.       WriteRelMove(moves->rmove, MOVEREL_SCALE);
  508.     else if (moves->mtype == MOVEREL_ZOOM) 
  509.       WriteRelMove(moves->rmove, MOVEREL_ZOOM);
  510.     else if (moves->mtype == MOVEABS)
  511.       WriteAbsMove(moves->amove);
  512.     else {
  513.       fprintf(stderr,"Invalid movement type: %c\n",moves->mtype);
  514.       exit(1);
  515.     }
  516.     moves = moves->next;
  517.   }
  518.   fclose(movefile);
  519.   if (Option.debug) printf("Moves written to file = %d\n\n",moves_logged);
  520. }
  521.  
  522.  
  523.  
  524.  
  525.  
  526.